home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et3_0-a1.lha / et3 / src / CollView.C < prev    next >
C/C++ Source or Header  |  1992-08-11  |  11KB  |  550 lines
  1. #ifdef __GNUG__
  2. #pragma implementation
  3. #endif
  4.  
  5. #include "CollView.h"
  6.  
  7. #include "Class.h"
  8. #include "String.h"
  9. #include "SeqColl.h"
  10. #include "VObject.h"
  11. #include "CmdNo.h"
  12. #include "Error.h"
  13. #include "Math.h"
  14. #include "WindowSystem.h"
  15.  
  16. extern bool testopen;
  17.  
  18. //---- CollectionView ----------------------------------------------------------
  19.  
  20. NewMetaImpl(CollectionView,View, (TP(coll), T(selection), T(gap), T(minExtent),
  21.                         T(rows), T(cols), TP(defaultItem)));
  22.  
  23. CollectionView::CollectionView(EvtHandler *eh, SeqCollection *m, CollViewOptions o,
  24.                         int r, int c) : View(eh, gRect0)
  25. {
  26.     SetFlag(o);
  27.     defaultItem= new VObject();
  28.     rows= r;
  29.     cols= c;
  30.     SetCollection(m);
  31. }
  32.  
  33. CollectionView::~CollectionView()
  34. {
  35.     if (coll) {
  36.     coll->RemoveObserver(this);
  37.     coll->FreeAll();
  38.     SafeDelete(coll);
  39.     }
  40.     SafeDelete(xPos);
  41.     SafeDelete(yPos);
  42.     SafeDelete(defaultItem);
  43. }
  44.  
  45. //---- init methods
  46.  
  47. void CollectionView::SetSelection(Rectangle newsel, bool sendcontrol)
  48. {
  49.     if (selection != newsel) {
  50.     if (IsOpen()) {
  51.         InvalidateRect(ItemRect(selection));
  52.         InvalidateRect(ItemRect(newsel));
  53.     }
  54.     selection= newsel;
  55.     }
  56.     if (sendcontrol)
  57.     DoSelect(selection, WindowSystem::Clicks);
  58. }
  59.  
  60. void CollectionView::SetColsRows(Point cr)
  61. {
  62.     cols= cr.x;
  63.     rows= cr.y;
  64.     Modified();
  65. }
  66.  
  67. void CollectionView::DoSelect(Rectangle r, int clicks)
  68. {
  69.     if (r.IsNotEmpty()) {
  70.     int partcode= clicks >= 2 ? cPartCollDoubleSelect : cPartCollSelect;
  71.     Control(GetId(), partcode, (void*) r.origin.y);
  72.     }
  73. }
  74.  
  75. void CollectionView::ClearSelection(bool)
  76. {
  77.     SetSelection(gRect0);
  78. }
  79.  
  80. void CollectionView::SetCollection(SeqCollection *m, bool freeold)
  81. {
  82.     if (coll) {
  83.     coll->RemoveObserver(this);
  84.     /*
  85.     {
  86.         coll->ForEach(VObject,Open)(FALSE);
  87.     }
  88.     */
  89.     {
  90.         coll->ForEach(VObject,ClearContainer)(this);
  91.     }
  92.     if (freeold) {
  93.         coll->FreeAll();
  94.         delete coll;
  95.     }
  96.     }
  97.     coll= m;
  98.     if (coll) {
  99.     coll->AssertClass(VObject);
  100.     {
  101.         coll->ForEach(VObject,SetContainer)(this);
  102.     }
  103.     if (IsOpen()) {
  104.         coll->ForEach(VObject,Open)(TRUE);
  105.     }
  106.     coll->AddObserver(this);
  107.     }
  108.     selection= gRect0;
  109.     Modified();
  110.     //if (IsOpen())
  111.     //    Scroll(cPartScrollAbs, gPoint0, FALSE);
  112. }
  113.  
  114. void CollectionView::SetDefaultItem(class VObject *d)
  115. { 
  116.     if (defaultItem)
  117.     delete defaultItem;
  118.     defaultItem= d;
  119. }
  120.  
  121. void CollectionView::SetMinExtent(Point e)
  122. {
  123.     if (minExtent != e) {
  124.     minExtent= e;
  125.     Modified();
  126.     }
  127. }
  128.  
  129. Metric CollectionView::GetMinSize()
  130. {
  131.     Update();
  132.     return GetExtent();
  133. }
  134.  
  135. void CollectionView::Open(bool m)
  136. {
  137.     View::Open(m);
  138.     if (testopen) {
  139.     if (m) {
  140.         if (coll) {
  141.         coll->ForEach(VObject,Open)(TRUE);
  142.         }
  143.     } else {
  144.         if (!IsOpen() && coll) {
  145.         coll->ForEach(VObject,Open)(FALSE);
  146.         }
  147.     }
  148.     }
  149. }
  150.  
  151. //---- layout
  152.  
  153. void CollectionView::ConstrainScroll(Point *p)
  154. {
  155.     if (xPos) {
  156.     bool outside;
  157.     Point pp= PointToItem(*p, &outside);
  158.     if (! outside)
  159.         p->y= ItemRect(0, pp.y).origin.y;
  160.     }
  161. }
  162.  
  163. void CollectionView::SetOrigin(Point at)
  164. {
  165.     View::SetOrigin(at);
  166.     if (coll && coll->Size() > 0) {
  167.     register int x, y;
  168.     at+= gap;
  169.     for (x= 0; x < cols; x++)
  170.         for (y= 0; y < rows; y++)
  171.         GetItem(x, y)->SetOrigin(Point(xPos[x]+at.x, yPos[y]+at.y));
  172.     }
  173. }
  174.  
  175. void CollectionView::Update()
  176. {
  177.     register VObject *gop;
  178.     register int x, y, ww, hh, w, h;
  179.     int xpos= 0, ypos= 0, sz;
  180.     Point g;
  181.  
  182.     if (!TestFlag(eCVModified))
  183.     return;
  184.     ResetFlag(eCVModified);
  185.  
  186.     if (coll == 0 || coll->Size() <= 0) {
  187.     ForceRedraw();
  188.     return;
  189.     }
  190.     
  191.     if (testopen) {
  192.     {
  193.         coll->ForEach(VObject,SetContainer)(this);
  194.     }
  195.     if (IsOpen()) {
  196.         coll->ForEach(VObject,Open)(TRUE);
  197.     }
  198.     }
  199.     
  200.     sz= coll->Size();
  201.     if (rows <= 0)
  202.     SetFlag(eCVExpandRows);
  203.     if (cols <= 0)
  204.     SetFlag(eCVExpandCols);
  205.     
  206.     if (TestFlag(eCVExpandRows) && TestFlag(eCVExpandCols)) {
  207.     cols= Math::Sqrt(sz);
  208.     rows= (sz+cols-1) / cols;
  209.     } else if (TestFlag(eCVExpandRows))
  210.     rows= (sz+cols-1) / cols;
  211.     else if (TestFlag(eCVExpandCols))
  212.     cols= (sz+rows-1) / rows;
  213.  
  214.     yPos= (int*) Realloc(yPos, (rows+1) * sizeof(int));
  215.     xPos= (int*) Realloc(xPos, (cols+1) * sizeof(int));
  216.  
  217.     xpos= ypos= 0;
  218.     g= 2*gap;
  219.     if (TestFlag(eCVGrid))
  220.     g+= gPoint1;
  221.     
  222.     for (x= 0; x < cols; x++) {
  223.     xPos[x]= xpos;
  224.     ww= minExtent.x;
  225.     for (y= 0; y < rows; y++) {
  226.         gop= GetItem(x, y);
  227.         gop->SetContainer(this);
  228.         if (!testopen) {
  229.         if (IsOpen())
  230.             gop->Open();
  231.         }
  232.         gop->CalcExtent();
  233.         w= gop->Width();
  234.         ww= Math::Max(ww, w);
  235.     }
  236.     xpos+= ww+g.x;
  237.     }
  238.     xPos[x]= xpos;
  239.  
  240.     for (y= 0; y < rows; y++) {
  241.     yPos[y]= ypos;
  242.     hh= minExtent.y;
  243.     for (x= 0; x < cols; x++) {
  244.         h= GetItem(x, y)->Height();
  245.         hh= Math::Max(hh, h);
  246.     }
  247.     ypos+= hh+g.y;
  248.     }
  249.     yPos[y]= ypos;
  250.  
  251.     for (x= 0; x < cols; x++)
  252.     for (y= 0; y < rows; y++)
  253.         GetItem(x, y)->SetContentRect(ItemRect(x, y).Inset(gap), FALSE);
  254.  
  255.     if (TestFlag(eCVGrid)) {
  256.     xpos--;
  257.     ypos--;
  258.     }
  259.     
  260.     ForceRedraw();
  261.     SetExtent(Point(xpos, ypos));
  262.     ForceRedraw();
  263. }
  264.  
  265. //---- update
  266.  
  267. void CollectionView::DoObserve(int, int part, void *, Object *op)
  268. {
  269.     if (part == cPartSenderDied)
  270.     coll= 0;
  271.     else if (op == coll)
  272.     Modified();
  273. }
  274.  
  275. void CollectionView::Modified()
  276. {
  277.     SetFlag(eCVModified);
  278.     if (IsOpen())
  279.     Update();
  280. }
  281.  
  282. //---- mapping
  283.  
  284. Point CollectionView::PointToItem(Point p, bool *outside)
  285. {
  286.     register int x, y;
  287.     register bool out= FALSE;
  288.     
  289.     if (coll == 0 || coll->Size() <= 0) {
  290.     if (outside)
  291.         *outside= TRUE;
  292.     return gPoint0;
  293.     }
  294.     Update();
  295.     p-= GetOrigin();
  296.     if (p.x < xPos[0]) {
  297.     out= TRUE;
  298.     x= 0;
  299.     } else if (p.x >= xPos[cols]) {
  300.     out= TRUE;
  301.     x= cols-1;
  302.     } else {
  303.     for (x= 0; x < cols; x++)
  304.         if (p.x >= xPos[x] && p.x < xPos[x+1])
  305.         break;
  306.     }
  307.     if (p.y < yPos[0]) {
  308.     out= TRUE;
  309.     y= 0;
  310.     } else if (p.y >= yPos[rows]) {
  311.     out= TRUE;
  312.     y= rows-1;
  313.     } else {
  314.     for (y= 0; y < rows; y++)
  315.         if (p.y >= yPos[y] && p.y < yPos[y+1])
  316.         break;
  317.     }
  318.     if (outside)
  319.     *outside= out;
  320.     return Point(x, y);
  321. }
  322.  
  323. Rectangle CollectionView::ItemRect(Rectangle r)
  324. {
  325.     Rectangle rr;
  326.  
  327.     if (r.IsEmpty())
  328.     return gRect0;
  329.     Update();
  330.     rr.origin.x= xPos[r.origin.x];
  331.     rr.origin.y= yPos[r.origin.y];
  332.     rr.extent.x= xPos[r.origin.x+r.extent.x] - rr.origin.x;
  333.     rr.extent.y= yPos[r.origin.y+r.extent.y] - rr.origin.y;
  334.     if (TestFlag(eCVGrid))
  335.     rr.extent-= gPoint1;
  336.     return rr+GetOrigin();
  337. }
  338.  
  339. Point CollectionView::ItemPos(VObject *g)
  340. {
  341.     VObject *gop;
  342.     Iter next(coll);
  343.  
  344.     Update();
  345.     for (int i= 0; gop= (VObject*) next(); i++)
  346.     if (gop == g)
  347.         break;
  348.     if (i >= coll->Size())
  349.     return gPoint_1;
  350.     return Point(i % cols, i / cols);
  351. }
  352.  
  353. Rectangle CollectionView::ItemRect(int x, int y)
  354. {
  355.     Update();
  356.     x= Math::Range(0, cols-1, x);
  357.     y= Math::Range(0, rows-1, y);
  358.     Rectangle r(xPos[x], yPos[y], xPos[x+1]-xPos[x], yPos[y+1]-yPos[y]);
  359.     if (TestFlag(eCVGrid))
  360.     r.extent-= gPoint1;
  361.     r.origin+= GetOrigin();
  362.     return r;
  363. }
  364.  
  365. VObject *CollectionView::GetItem(int x, int y)
  366. {
  367.     VObject *vop= 0;
  368.     int ix= y*cols+x;
  369.     
  370.     if (ix >= 0 && ix < coll->Size())
  371.     vop= (VObject*)coll->At(ix);
  372.     return vop ? vop : defaultItem;
  373. }
  374.  
  375. //---- event handlung
  376.  
  377. Command *CollectionView::DoLeftButtonDownCommand(Point lp, Token t, int clicks)
  378. {
  379.     if (coll && coll->Size() > 0) {
  380.     ClearSelection();
  381.     return new CellSelector(this, TestFlag(eCVDontStuckToBorder));
  382.     }
  383.     return View::DoLeftButtonDownCommand(lp, t, clicks);
  384. }
  385.  
  386. Command *CollectionView::DoKeyCommand(int ch, Token)
  387. {
  388.     register VObject *gop= 0;
  389.     register int i;
  390.     int start= 0;
  391.     Rectangle r= GetViewedRect();
  392.     
  393.     if (r.IsNotEmpty()) {
  394.     start= r.origin.y+r.extent.y;
  395.     if (start <= GetExtent().y)
  396.         start= PointToItem(Point(0,start)).y;
  397.     }
  398.  
  399.     for (i= 0; i < rows; i++) {
  400.     gop= GetItem(0, (start+i) % rows);
  401.     if (gop && (sortmap[gop->AsString()[0]] == sortmap[ch]))
  402.         break;
  403.     }
  404.  
  405.     if (gop)
  406.     RevealAlign(ItemRect(Rectangle(ItemPos(gop), gPoint1)));
  407.     return gNoChanges;
  408. }
  409.  
  410. //---- drawing
  411.  
  412. void CollectionView::Draw(Rectangle r)
  413. {
  414.     register int x, y;
  415.     register VObject *gop;
  416.     Point p1, p2;
  417.  
  418.     if (coll == 0 || coll->Size() <= 0)
  419.     return;
  420.     p1= PointToItem(r.NW());
  421.     p2= PointToItem(r.SE()+gPoint1);
  422.     int i= 0;
  423.     for (x= p1.x; x <= p2.x; x++) {
  424.     for (y= p1.y; y <= p2.y; y++) {
  425.         i++;
  426.         gop= GetItem(x, y);
  427.         gop->DrawAll(gop->contentRect,
  428.             selection.ContainsPoint(Point(x, y)) && gop->Enabled());
  429.     }
  430.     }
  431.     if (TestFlag(eCVGrid)) {
  432.     GrSetPenNormal();
  433.     DrawGrid(p1, p2);
  434.     }
  435. } 
  436.  
  437. void CollectionView::DrawGrid(Point p1, Point p2)
  438. {
  439.     register int x, y;
  440.     int xx= 0, yy= 0;
  441.     Point o= GetOrigin();
  442.  
  443.     if (p2.x >= cols-1)
  444.     xx= 1;
  445.     if (p2.y >= rows-1)
  446.     yy= 1;
  447.     for (x= p1.x; x <= p2.x-xx; x++)
  448.     GrLine(Point(xPos[x+1]-1, yPos[p1.y])+o, Point(xPos[x+1]-1, yPos[p2.y+1]-1)+o);
  449.     for (y= p1.y; y <= p2.y-yy; y++)
  450.     GrLine(Point(xPos[p1.x], yPos[y+1]-1)+o, Point(xPos[p2.x+1]-1, yPos[y+1]-1)+o);
  451. }
  452.  
  453. //---- input/output
  454.  
  455. OStream& CollectionView::PrintOn(OStream &s)
  456. {
  457.     Object::PrintOn(s);
  458.     return s << gap SP << minExtent SP << rows SP << cols SP << defaultItem SP << coll SP;
  459. }
  460.  
  461. bool CollectionView::PrintOnWhenObserving(Object *from)
  462. {
  463.     return from != coll;
  464. }
  465.  
  466. IStream& CollectionView::ReadFrom(IStream &s)
  467. {
  468.     SeqCollection *m;
  469.     VObject *di= 0;
  470.  
  471.     Object::ReadFrom(s);
  472.     s >> gap >> minExtent >> rows >> cols >> di >> m;
  473.     SetCollection(m);
  474.     SetDefaultItem(di);
  475.     return s;
  476. }
  477.  
  478. void CollectionView::CollectParts(Collection* col)
  479. {
  480.     View::CollectParts(col);
  481.     if (coll && coll->Size() < 12) // hack
  482.     col->Add(coll);
  483. }
  484.  
  485. VObject *CollectionView::Detect(BoolFun find, void *arg)
  486. {
  487.     if (coll) {
  488.     Iter next(coll);
  489.     register VObject *v1, *v2;
  490.  
  491.     while (v1= (VObject*) next())
  492.         if (v2= v1->Detect(find, arg))
  493.         return v2;
  494.     }
  495.     return 0;
  496. }
  497.  
  498. //---- CellSelector ------------------------------------------------------------
  499.  
  500. CellSelector::CellSelector(CollectionView* v, bool dontstucktoborder)
  501. { 
  502.     SetFlag(eCmdNoReplFeedback);
  503.     lvp= v;
  504.     last= 0;
  505.     dontstuck= dontstucktoborder;
  506. }
  507.  
  508. void CellSelector::TrackFeedback(Point, Point pp, bool on)
  509. {
  510.     if (on) {
  511.     if (itemptr == last) {
  512.         if (last)
  513.         last->DoTrackMouse((TrackPhase)eTrackMove, pp);
  514.     } else {
  515.         if (last)
  516.         last->DoTrackMouse((TrackPhase)eTrackRelease, pp);
  517.         if (itemptr)
  518.         itemptr->DoTrackMouse((TrackPhase)eTrackPress, pp);
  519.     }
  520.     last= itemptr;
  521.     }
  522. }
  523.  
  524. Command *CellSelector::TrackMouse(TrackPhase atp, Point, Point, Point np)
  525. {
  526.     bool outside= FALSE;
  527.     
  528.     item= lvp->PointToItem(np, &outside);
  529.     if (outside && dontstuck)
  530.     itemptr= 0;
  531.     else
  532.     itemptr= lvp->GetItem(item.x, item.y);
  533.     
  534.     switch (atp) {
  535.     case eTrackRelease:
  536.     if (last)
  537.         last->DoTrackMouse((TrackPhase)eTrackRelease, np);
  538.     if (itemptr && itemptr->Enabled())
  539.         lvp->SetSelection(Rectangle(item, gPoint1), TRUE);
  540.     else
  541.         lvp->SetSelection(gRect0, TRUE);
  542.     case eTrackExit:
  543.     return gNoChanges;
  544.     default:
  545.     break;
  546.     }
  547.     return this;
  548. }
  549.  
  550.